///*
// * This file is part of JGAP.
// *
// * JGAP offers a dual license model containing the LGPL as well as the MPL.
// *
// * For licensing information please see the file license.txt included with JGAP
// * or have a look at the top of class org.jgap.Chromosome which representatively
// * includes the JGAP license policy applicable for any file delivered with JGAP.
// */
//package org.jgap.impl;
//
//import java.util.*;
//import org.jgap.*;
//
///**
// * A Gene implementation that supports a double values for its allele.
// * Upper and lower bounds may optionally be provided to restrict the range
// * of legal values allowed by this Gene instance.<p>
// * Partly copied from IntegerGene.
// *
// * @author Klaus Meffert
// * @since 1.1
// */
//public class DoubleGene
//    extends NumberGene implements IPersistentRepresentation {
//  /** String containing the CVS revision. Read out via reflection!*/
//  private final static String CVS_REVISION = "$Revision: 1.39 $";
//
//  /**
//   * The upper bounds of values represented by this Gene. If not explicitly
//   * provided by the user, this should be set to Double.MAX_VALUE.
//   */
//  private double m_upperBound;
//
//  /**
//   * The lower bounds of values represented by this Gene. If not explicitly
//   * provided by the user, this should be set to Double.MIN_VALUE
//   */
//  private double m_lowerBound;
//
//  /**
//   * Constructs a new DoubleGene with default settings. No bounds will
//   * be put into effect for values (alleles) of this Gene instance, other
//   * than the standard range of double values.<p>
//   * Attention: The configuration used is the one set with the static method
//   * Genotype.setConfiguration.
//   *
//   * @throws InvalidConfigurationException
//   *
//   * @author Neil Rotstan
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  public DoubleGene()
//      throws InvalidConfigurationException {
//    this(Genotype.getStaticConfiguration());
//  }
//
//  /**
//   * Constructs a new DoubleGene with default settings. No bounds will
//   * be put into effect for values (alleles) of this Gene instance, other
//   * than the standard range of double values.
//   *
//   * @param a_config the configuration to use
//   * @throws InvalidConfigurationException
//   *
//   * @author Klaus Meffert
//   * @since 3.0
//   */
//  public DoubleGene(final Configuration a_config)
//      throws InvalidConfigurationException {
//    this(a_config, - (Double.MAX_VALUE / 2),
//         Double.MAX_VALUE / 2);
//  }
//
//  /**
//   * Constructs a new DoubleGene with the specified lower and upper
//   * bounds for values (alleles) of this Gene instance.
//   *
//   * @param a_config the configuration to use
//   * @param a_lowerBound the lowest value that this Gene may possess,
//   * inclusively
//   * @param a_upperBound the highest value that this Gene may possess,
//   * inclusively
//   * @throws InvalidConfigurationException
//   *
//   * @author Klaus Meffert
//   * @since 2.0
//   */
//  public DoubleGene(final Configuration a_config, final double a_lowerBound,
//                    final double a_upperBound)
//      throws InvalidConfigurationException {
//    super(a_config);
//    m_lowerBound = a_lowerBound;
//    m_upperBound = a_upperBound;
//  }
//
//  /**
//   * Provides an implementation-independent means for creating new Gene
//   * instances.
//   *
//   * @return a new Gene instance of the same type and with the same
//   * setup as this concrete Gene
//   *
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  protected Gene newGeneInternal() {
//    try {
//      DoubleGene result = new DoubleGene(getConfiguration(), m_lowerBound,
//                                         m_upperBound);
//      return result;
//    }
//    catch (InvalidConfigurationException iex) {
//      throw new IllegalStateException(iex.getMessage());
//    }
//  }
//
//  /**
//   * Retrieves a string representation of this Gene that includes any
//   * information required to reconstruct it at a later time, such as its
//   * value and internal state. This string will be used to represent this
//   * Gene in XML persistence. This is an optional method but, if not
//   * implemented, XML persistence and possibly other features will not be
//   * available. An UnsupportedOperationException should be thrown if no
//   * implementation is provided.
//   *
//   * @return a string representation of this Gene's current state
//   *
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  public String getPersistentRepresentation() {
//    // The persistent representation includes the value, lower bound,
//    // and upper bound. Each is separated by a colon.
//    // --------------------------------------------------------------
//    String s;
//    if (getInternalValue() == null) {
//      s = "null";
//    }
//    else {
//      s = getInternalValue().toString();
//    }
//    return s + PERSISTENT_FIELD_DELIMITER + m_lowerBound
//        + PERSISTENT_FIELD_DELIMITER + m_upperBound;
//  }
//
//  /**
//   * Sets the value and internal state of this Gene from the string
//   * representation returned by a previous invocation of the
//   * getPersistentRepresentation() method. This is an optional method but,
//   * if not implemented, XML persistence and possibly other features will not
//   * be available. An UnsupportedOperationException should be thrown if no
//   * implementation is provided.
//   *
//   * @param a_representation the string representation retrieved from a
//   * prior call to the getPersistentRepresentation() method
//   *
//   * @throws UnsupportedOperationException to indicate that no implementation
//   * is provided for this method
//   * @throws UnsupportedRepresentationException if this Gene implementation
//   * does not support the given string representation
//   *
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  public void setValueFromPersistentRepresentation(String a_representation)
//      throws UnsupportedRepresentationException {
//    /**@todo unify first part of method with IntegerGene*/
//    if (a_representation != null) {
//      StringTokenizer tokenizer =
//          new StringTokenizer(a_representation,
//                              PERSISTENT_FIELD_DELIMITER);
//      // Make sure the representation contains the correct number of
//      // fields. If not, throw an exception.
//      // -----------------------------------------------------------
//      if (tokenizer.countTokens() != 3) {
//        throw new UnsupportedRepresentationException(
//            "The format of the given persistent representation "
//            + " is not recognized: it does not contain three tokens: "
//            + a_representation);
//      }
//      String valueRepresentation = tokenizer.nextToken();
//      String lowerBoundRepresentation = tokenizer.nextToken();
//      String upperBoundRepresentation = tokenizer.nextToken();
//      // First parse and set the representation of the value.
//      // ----------------------------------------------------
//      if (valueRepresentation.equals("null")) {
//        setAllele(null);
//      }
//      else {
//        try {
//          setAllele(new Double(Double.parseDouble(valueRepresentation)));
//        }
//        catch (NumberFormatException e) {
//          throw new UnsupportedRepresentationException(
//              "The format of the given persistent representation " +
//              "is not recognized: field 1 does not appear to be " +
//              "a double value.");
//        }
//      }
//      // Now parse and set the lower bound.
//      // ----------------------------------
//      try {
//        m_lowerBound =
//            Double.parseDouble(lowerBoundRepresentation);
//      }
//      catch (NumberFormatException e) {
//        throw new UnsupportedRepresentationException(
//            "The format of the given persistent representation " +
//            "is not recognized: field 2 does not appear to be " +
//            "a double value.");
//      }
//      // Now parse and set the upper bound.
//      // ----------------------------------
//      try {
//        m_upperBound =
//            Double.parseDouble(upperBoundRepresentation);
//      }
//      catch (NumberFormatException e) {
//        throw new UnsupportedRepresentationException(
//            "The format of the given persistent representation " +
//            "is not recognized: field 3 does not appear to be " +
//            "a double value.");
//      }
//    }
//  }
//
//  /**
//   * Retrieves the double value of this Gene, which may be more convenient in
//   * some cases than the more general getAllele() method.
//   *
//   * @return the double value of this Gene
//   * @since 1.1
//   */
//  public double doubleValue() {
//    return ( (Double) getAllele()).doubleValue();
//  }
//
//  /**
//   * Sets the value (allele) of this Gene to a random Double value between
//   * the lower and upper bounds (if any) of this Gene.
//   *
//   * @param a_numberGenerator the random number generator that should be used
//   * to create any random values. It's important to use this generator to
//   * maintain the user's flexibility to configure the genetic engine to use the
//   * random number generator of their choice
//   *
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  public void setToRandomValue(RandomGenerator a_numberGenerator) {
//    // maps the randomly determined value to the current bounds.
//    // ---------------------------------------------------------
//    setAllele(new Double( (m_upperBound - m_lowerBound) *
//                         a_numberGenerator.nextDouble() + m_lowerBound));
//  }
//
//  /**
//   * Compares to objects by first casting them into their expected type
//   * (e.g. Integer for IntegerGene) and then calling the compareTo-method
//   * of the casted type.
//   *
//   * @param o1 first object to be compared, which is always not null
//   * @param o2 second object to be compared, which is always not null
//   * @return a negative integer, zero, or a positive integer as this object
//   * is less than, equal to, or greater than the object provided for comparison
//   *
//   * @since 1.1
//   */
//  protected int compareToNative(Object o1, Object o2) {
//    return ( (Double) o1).compareTo( (Double) o2);
//  }
//
//  /**
//   * Maps the value of this DoubleGene to within the bounds specified by
//   * the m_upperBounds and m_lowerBounds instance variables. The value's
//   * relative position within the double range will be preserved within the
//   * bounds range (in other words, if the value is about halfway between the
//   * double max and min, then the resulting value will be about halfway
//   * between the upper bounds and lower bounds). If the value is null or
//   * is already within the bounds, it will be left unchanged.
//   *
//   * @author Neil Rotstan
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  protected void mapValueToWithinBounds() {
//    if (getAllele() != null) {
//      Double d_value = ( (Double) getAllele());
//      // If the value exceeds either the upper or lower bounds, then
//      // map the value to within the legal range. To do this, we basically
//      // calculate the distance between the value and the double min,
//      // then multiply it with a random number and then care that the lower
//      // boundary is added.
//      // ------------------------------------------------------------------
//      if (d_value.doubleValue() > m_upperBound ||
//          d_value.doubleValue() < m_lowerBound) {
//        RandomGenerator rn;
//        if (getConfiguration() != null) {
//          rn = getConfiguration().getRandomGenerator();
//        }
//        else {
//          rn = new StockRandomGenerator();
//        }
//        setAllele(new Double(rn.nextDouble()
//                             * (m_upperBound - m_lowerBound) + m_lowerBound));
//      }
//    }
//  }
//
//  /**
//   * See interface Gene for description.
//   * @param index ignored (because there is only 1 atomic element)
//   * @param a_percentage percentage of mutation (greater than -1 and smaller
//   * than 1)
//   *
//   * @author Klaus Meffert
//   * @since 1.1
//   */
//  public void applyMutation(int index, double a_percentage) {
//    double range = (m_upperBound - m_lowerBound) * a_percentage;
//    double newValue = doubleValue() + range;
//    setAllele(new Double(newValue));
//  }
//
//  /**
//   * Modified hashCode() function to return different hashcodes for differently
//   * ordered genes in a chromosome.
//   * @return -3 if no allele set, otherwise value return by BaseGene.hashCode()
//   *
//   * @author Klaus Meffert
//   * @since 2.2
//   */
//  public int hashCode() {
//    if (getInternalValue() == null) {
//      return -3;
//    }
//    else {
//      return super.hashCode();
//    }
//  }
//
//  /**
//   * @return string representation of this Gene's value that may be useful for
//   * display purposes
//   *
//   * @author Klaus Meffert
//   * @since 2.4
//   */
//  public String toString() {
//    String s = "DoubleGene(" + m_lowerBound + "," + m_upperBound + ")"
//        + "=";
//    if (getInternalValue() == null) {
//      s += "null";
//    }
//    else {
//      s += getInternalValue().toString();
//    }
//    return s;
//  }
//
//  /**
//   * @return the lower bound set
//   * @author Klaus Meffert
//   * @since 3.0
//   */
//  public double getLowerBound() {
//    return m_lowerBound;
//  }
//
//  /**
//   * @return the upper bound set
//   * @author Klaus Meffert
//   * @since 3.0
//   */
//  public double getUpperBound() {
//    return m_upperBound;
//  }
//}
